There are many ways to use an interactive whiteboard for marking up information. The board can show a white background which allows the user to draw as if it were a regular whiteboard. Alternatively, a personal computer (PC) display can be shown on the background and the user can draw on the displayed image.
Using techniques such as the SMART Technologies, Inc. drivers and a SMART Board®, a user can display any background, including a word document, an image, a web page, a PowerPoint presentation, a video, an entire PC display or virtually anything else. When the user picks up a pen from the SMART Board® pen tray, the SMART Board® drivers capture the current screen and freeze it. Any strokes written by the user are overlaid on the frozen screen image. If a PC is connected to the SMART Notebook™ software, even if a video is running, the image is frozen while the user writes. Once the user indicates the she is finished drawing through the user interface, the screen image with the strokes is captured and stored and the screen is unfrozen.
There are a number of problems associated with current whiteboard systems.
A first problem with current interactive whiteboard systems is that there is a separation between the source of the content and the source of the markup, or strokes, on the whiteboard. The users provide content (e.g., images) via video, such as by plugging in a personal computer (PC) and strokes are made by a user at the whiteboard. Because the images and strokes are sourced independently, they can get out of sync with each other when the image changes. For example, if a user scrolls an image at the PC, the images changes on the whiteboard but the strokes made to the previously displayed image may still remain and not be cleared until a user request. This makes such existing whiteboard systems sluggish. One could attempt to freeze the content and allow the markup to occur on the content at that time, but then the user cannot scroll the image or zoom into a portion of it. This is a cumbersome approach.
Another problem with current whiteboard systems is that they do not include a user interface that provides a positive user experience. Users often want to keep track of the images upon which they have added markups. For example, as a user is using the whiteboard and marking up content, the user would like to keep their strokes with the old content even if the content has changed. In order to save a page and any strokes made on whiteboard over content being displayed thereby after a change of the displayed content, existing whiteboard systems require a user who is controlling the content that is being displayed by the whiteboard to return to the page onto which the strokes were drawn to then allow the whiteboard user to save the page with image and strokes together. Thereafter, the user controlling the supply of content to the whiteboard system can change to a new page, and the whiteboard user can delete strokes and begin to mark up the next page. This is a very cumbersome process.
Lastly, another problem associated with current whiteboard systems is that they do not provide print output of what transpired in a session with the whiteboard.
Another solution is to have the strokes and content remain independent using an independent stroke layer. A problem with this approach is the when the image changes, the old strokes remain on the display. The portion of the document over which the strokes were written may no longer be. Thus, if the image is scrolled or changed, the strokes remain.
Since there are hundreds of thousands (or perhaps millions) of applications available for the PC, Mac and Linux platforms, and many different stroke input technologies, it is a complex problem to integrate stroke input techniques with every program.